{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "01c94f31",
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets = ['CUB', 'Derm7pt', 'RIVAL10']\n",
    "use_dataset = datasets[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3bea6c59",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import torch\n",
    "import joblib\n",
    "\n",
    "notebook_dir = os.getcwd()\n",
    "project_root_path = os.path.dirname(notebook_dir)\n",
    "sys.path.insert(0, project_root_path)\n",
    "\n",
    "from src.config import PROJECT_ROOT, CUB_CONFIG, DERM7PT_CONFIG, RIVAL10_CONFIG  # noqa: E402\n",
    "import numpy as np  # noqa: E402\n",
    "import matplotlib.pyplot as plt  # noqa: E402"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7845c267",
   "metadata": {},
   "outputs": [],
   "source": [
    "if use_dataset == 'CUB':\n",
    "    config_dict = CUB_CONFIG\n",
    "    DATASET_PATH =  os.path.join(PROJECT_ROOT, 'output', 'intervention', 'CUB')\n",
    "    MODEL_PATH =  os.path.join(PROJECT_ROOT, 'models', 'CUB')\n",
    "elif use_dataset == 'Derm7pt':\n",
    "    config_dict = DERM7PT_CONFIG\n",
    "    DATASET_PATH =  os.path.join(PROJECT_ROOT, 'output', 'intervention', 'Derm7pt')\n",
    "    MODEL_PATH =  os.path.join(PROJECT_ROOT, 'models', 'Derm7pt')\n",
    "else:\n",
    "    config_dict = RIVAL10_CONFIG\n",
    "    DATASET_PATH =  os.path.join(PROJECT_ROOT, 'output', 'intervention', 'RIVAL10')\n",
    "    MODEL_PATH =  os.path.join(PROJECT_ROOT, 'models', 'RIVAL10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e1e68e5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/pb/Documents/career/lab_ujm/clpc-cbm-model/models/RIVAL10/lin_model.joblib'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.join(MODEL_PATH, 'lin_model.joblib')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "600faac0",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_concepts = config_dict['N_TRIMMED_CONCEPTS']\n",
    "num_classes = config_dict['N_CLASSES']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3810908f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: mps\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available()\n",
    "                    else \"mps\" if torch.backends.mps.is_available()\n",
    "                    else \"cpu\")\n",
    "print(f\"Using device: {device}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dd1d270",
   "metadata": {},
   "source": [
    "# Load and Transform Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d572ec27",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data for linear model\n",
    "lin_C_hat = np.load(os.path.join(DATASET_PATH, 'C_hat_linear.npy'))\n",
    "lin_Y = np.load(os.path.join(DATASET_PATH, 'Y_linear.npy'))\n",
    "lin_model = joblib.load(os.path.join(MODEL_PATH, 'lin_model.joblib'))\n",
    "\n",
    "# Load data for CLC model\n",
    "clc_C_hat = torch.load(os.path.join(DATASET_PATH, 'C_hat_clc.npy'))\n",
    "clc_Y = torch.load(os.path.join(DATASET_PATH, 'Y_clc.npy'))\n",
    "clc_model = torch.load(os.path.join(MODEL_PATH, 'clc_model.pth'),\n",
    "                    weights_only=False, map_location=device)\n",
    "\n",
    "# # Load class-level concepts\n",
    "# class_level_concepts_path = os.path.join(PROJECT_ROOT, 'output', use_dataset, 'class_level_concepts.npy')\n",
    "# class_level_concepts = np.load(class_level_concepts_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "247e080c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Generate class-level concept values for each instance\n",
    "# clc_l_concept_values = []\n",
    "# for y in clc_Y:\n",
    "#     clc_l_concept_values.append(class_level_concepts[y])\n",
    "\n",
    "# clc_l_concept_values = np.array(clc_l_concept_values)\n",
    "# clc_l_concept_values = torch.tensor(clc_l_concept_values, device=device, dtype=torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d51027e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear model accuracy: 0.0000\n",
      "CLC model accuracy: 0.0000\n"
     ]
    }
   ],
   "source": [
    "# Check initial model accuracy\n",
    "print(f\"Linear model accuracy: {lin_model.score(lin_C_hat, lin_Y):.4f}\")\n",
    "\n",
    "with torch.no_grad():\n",
    "    clc_Y_pred = clc_model.predict(clc_C_hat)\n",
    "    clc_accuracy = (clc_Y_pred == clc_Y).sum().item()/len(clc_Y_pred)\n",
    "    print(f\"CLC model accuracy: {clc_accuracy:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b6d7d08",
   "metadata": {},
   "source": [
    "# Intervention Utilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "98e8177e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_intervention_matrices_gain(model, C_hat, Y_test):\n",
    "    model_weights = model.coef_\n",
    "\n",
    "    concept_gain_rankings = np.zeros_like(C_hat)\n",
    "    expected_values = np.zeros_like(C_hat)\n",
    "\n",
    "    for instance_idx, concept_vector in enumerate(C_hat):\n",
    "        true_label = Y_test[instance_idx]\n",
    "        class_weights = model_weights[true_label]\n",
    "        concept_gains = np.zeros(len(class_weights))\n",
    "        instance_expected_vals = np.zeros(len(class_weights))\n",
    "\n",
    "        for concept_idx, concept_weight in enumerate(class_weights):\n",
    "            # Binary value based on concept weight direction\n",
    "            expected_concept_value = 1 if concept_weight > 0 else 0\n",
    "            instance_expected_vals[concept_idx] = expected_concept_value\n",
    "\n",
    "            # Calculate gain by comparing expected vs pred label, scaled by weight\n",
    "            concept_gains[concept_idx] = ((expected_concept_value - concept_vector[concept_idx]) * concept_weight)\n",
    "\n",
    "        expected_values[instance_idx] = instance_expected_vals\n",
    "        concept_gain_rankings[instance_idx] = (concept_gains)\n",
    "\n",
    "    concept_indices_by_gain = np.argsort(concept_gain_rankings, axis=1)[:, ::-1]\n",
    "\n",
    "    return concept_indices_by_gain, expected_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e1c3165b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_intervention_matrices_weight(model, C_hat, Y_test):\n",
    "    model_weights = model.coef_\n",
    "    weight_matrix = []\n",
    "\n",
    "    for idx in range(len(C_hat)):\n",
    "        instance_label = Y_test[idx]\n",
    "        weight_matrix.append(model_weights[instance_label])\n",
    "\n",
    "    weight_matrix = np.array(weight_matrix)\n",
    "    weight_indices_sorted = np.argsort(np.abs(weight_matrix), axis=1)[:, ::-1]\n",
    "\n",
    "    return weight_indices_sorted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "c3656208",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_prototype_gain_matrices(model, C_hat, Y_true):\n",
    "    prototypes = model.get_binary_prototypes()\n",
    "\n",
    "    gain_matrix = np.zeros((C_hat.shape[0], C_hat.shape[1]))\n",
    "    expected_values = np.zeros((C_hat.shape[0], C_hat.shape[1]))\n",
    "\n",
    "    for instance_idx, concept_vector in enumerate(C_hat):\n",
    "        pred_label = Y_true[instance_idx]\n",
    "        prototype = prototypes[pred_label].cpu().detach().numpy()\n",
    "        gain_vector = np.abs(prototype-concept_vector.cpu().detach().numpy())\n",
    "        gain_matrix[instance_idx] = gain_vector\n",
    "        expected_values[instance_idx] = prototype\n",
    "\n",
    "    concept_indices_by_gain = np.argsort(gain_matrix, axis=1)[:, ::-1]\n",
    "    expected_values = torch.tensor(expected_values, device=device, dtype=torch.float32)\n",
    "\n",
    "    return concept_indices_by_gain, expected_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1370dea1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def compute_class_level_gain_matrices(C_hat, Y_true, class_level_concepts):\n",
    "#     gain_matrix = np.zeros((C_hat.shape[0], C_hat.shape[1]))\n",
    "\n",
    "#     for instance_idx, concept_vector in enumerate(C_hat):\n",
    "#         pred_label = Y_true[instance_idx]\n",
    "#         clc = class_level_concepts[pred_label]\n",
    "#         gain_vector = np.abs(clc-concept_vector.cpu().detach().numpy())\n",
    "#         gain_matrix[instance_idx] = gain_vector\n",
    "\n",
    "#     concept_indices_by_gain = np.argsort(gain_matrix, axis=1)[:, ::-1]\n",
    "\n",
    "#     return concept_indices_by_gain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2dacf645",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_numpy_intervention(model, C_hat, Y_true, concept_indices_by_gain, expected_values):\n",
    "    C_hat_intervened = C_hat.copy()\n",
    "\n",
    "    # Calculate initial accuracy\n",
    "    initial_predictions = model.predict(C_hat_intervened)\n",
    "    misclassified_mask = (initial_predictions != Y_true)\n",
    "\n",
    "    accuracy = model.score(C_hat_intervened, Y_true)\n",
    "    accuracies = [accuracy]\n",
    "\n",
    "    # Run intervention steps\n",
    "    intervention_step = 0\n",
    "    while np.any(misclassified_mask) and intervention_step < C_hat.shape[1]:\n",
    "        # Get misclassified indices\n",
    "        indices_to_intervene = np.where(misclassified_mask)[0]\n",
    "\n",
    "        if len(indices_to_intervene) == 0:\n",
    "            break\n",
    "\n",
    "        # Select concepts to change based on ranking\n",
    "        concepts_to_change = concept_indices_by_gain[\n",
    "            indices_to_intervene, intervention_step\n",
    "        ]\n",
    "\n",
    "        # Apply intervention\n",
    "        C_hat_intervened[indices_to_intervene, concepts_to_change] = \\\n",
    "            expected_values[indices_to_intervene, concepts_to_change]\n",
    "\n",
    "        # Re-evaluate\n",
    "        current_predictions = model.predict(C_hat_intervened)\n",
    "        misclassified_mask = (current_predictions != Y_true)\n",
    "        accuracy = model.score(C_hat_intervened, Y_true)\n",
    "        accuracies.append(accuracy)\n",
    "\n",
    "        intervention_step += 1\n",
    "\n",
    "    print(f\"Intervention completed after {intervention_step} steps\")\n",
    "    print(f\"Final accuracy: {accuracies[-1]:.4f}\")\n",
    "\n",
    "    return accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "4bb64c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def predict_nearest_class(C_hat, class_level_concepts):\n",
    "#     # Convert to numpy if needed\n",
    "#     if isinstance(C_hat, torch.Tensor):\n",
    "#         C_hat_numpy = C_hat.cpu().detach().numpy()\n",
    "#     else:\n",
    "#         C_hat_numpy = C_hat\n",
    "\n",
    "#     # Calculate differences between each test instance and all class-level concepts\n",
    "#     predicted_classes = []\n",
    "\n",
    "#     for i, test_instance in enumerate(C_hat_numpy):\n",
    "#         # Calculate absolute differences to each class concept\n",
    "#         instance_diffs = np.abs(test_instance - class_level_concepts)\n",
    "\n",
    "#         # Sum the differences along concept dimension to get total deviation for each class\n",
    "#         instance_distances = np.sum(instance_diffs, axis=1)\n",
    "\n",
    "#         # Find which class has the minimum distance\n",
    "#         min_class = np.argmin(instance_distances)\n",
    "#         predicted_classes.append(min_class)\n",
    "\n",
    "#     return np.array(predicted_classes)\n",
    "\n",
    "\n",
    "def run_torch_intervention(model, C_hat, Y_true, concept_indices_by_gain, expected_values, use_clc_d_accuracy=False, class_level_concepts=None):\n",
    "    # Clone data to avoid modifying originals\n",
    "    C_hat_intervened = C_hat.clone().detach()\n",
    "    Y_true_device = Y_true.to(C_hat_intervened.device)\n",
    "    # Y_true_numpy = Y_true_device.cpu().numpy() if use_clc_d_accuracy else None\n",
    "\n",
    "    # Get initial predictions and accuracy\n",
    "    # if use_clc_d_accuracy and class_level_concepts is not None:\n",
    "    #     # CLC-D specific accuracy calculation using nearest neighbor\n",
    "    #     predicted_classes = predict_nearest_class(C_hat_intervened, class_level_concepts)\n",
    "    #     current_accuracy = np.mean(predicted_classes == Y_true_numpy)\n",
    "\n",
    "    #     # Generate mask for intervention\n",
    "    #     misclassified_mask = torch.tensor(\n",
    "    #         predicted_classes != Y_true_numpy,\n",
    "    #         device=C_hat_intervened.device\n",
    "    #     )\n",
    "    # else:\n",
    "    # Standard accuracy calculation\n",
    "    with torch.no_grad():\n",
    "        initial_predictions = model.predict(C_hat_intervened)\n",
    "    misclassified_mask = (initial_predictions != Y_true_device)\n",
    "    current_accuracy = (~misclassified_mask).float().mean().item()\n",
    "\n",
    "\n",
    "    accuracies = [0]\n",
    "\n",
    "    # Run intervention steps\n",
    "    intervention_step = 0\n",
    "    while misclassified_mask.any() and intervention_step < C_hat.shape[1]:\n",
    "        indices_to_intervene = torch.where(misclassified_mask)[0]\n",
    "\n",
    "        if len(indices_to_intervene) == 0:\n",
    "            break\n",
    "\n",
    "        # Select concepts to change\n",
    "        concepts_to_change = concept_indices_by_gain[\n",
    "            indices_to_intervene.cpu().numpy(), intervention_step\n",
    "        ]\n",
    "\n",
    "        # Apply intervention\n",
    "        C_hat_intervened[indices_to_intervene, concepts_to_change] = \\\n",
    "            expected_values[indices_to_intervene, concepts_to_change]\n",
    "\n",
    "        # Re-evaluate with appropriate accuracy calculation\n",
    "        # if use_clc_d_accuracy and class_level_concepts is not None:\n",
    "        #     # CLC-D specific accuracy calculation using nearest neighbor\n",
    "        #     predicted_classes = predict_nearest_class(C_hat_intervened, class_level_concepts)\n",
    "        #     current_accuracy = np.mean(predicted_classes == Y_true_numpy)\n",
    "\n",
    "        #     # Update mask\n",
    "        #     misclassified_mask = torch.tensor(\n",
    "        #         predicted_classes != Y_true_numpy,\n",
    "        #         device=C_hat_intervened.device\n",
    "        #     )\n",
    "        # else:\n",
    "        # Standard accuracy calculation\n",
    "        with torch.no_grad():\n",
    "            current_predictions = model.predict(C_hat_intervened)\n",
    "        misclassified_mask = (current_predictions != Y_true_device)\n",
    "        current_accuracy = (~misclassified_mask).float().mean().item()\n",
    "\n",
    "\n",
    "        accuracies.append(current_accuracy)\n",
    "        intervention_step += 1\n",
    "\n",
    "    print(f\"Intervention completed after {intervention_step} steps\")\n",
    "    print(f\"Final accuracy: {accuracies[-1]:.4f}\")\n",
    "\n",
    "    return accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4722b4c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_intervention_results(model_results_dict, dataset_name):\n",
    "    plt.figure(figsize=(6,6))\n",
    "\n",
    "    line_styles = {\n",
    "        'LR': '-',\n",
    "        'LR-Weight': '-.',\n",
    "        'CLPC': '--',\n",
    "        'CLC-D': '-.'\n",
    "    }\n",
    "\n",
    "    markers = {\n",
    "        'LR': 'o',\n",
    "        'LR-Weight': '^',\n",
    "        'CLPC': 'D',\n",
    "        'CLC-D': '^',\n",
    "    }\n",
    "\n",
    "    # Find the minimum length to ensure consistency\n",
    "    # max_len = max(len(accs) for accs in model_results_dict.values())\n",
    "\n",
    "    # Plot with distinct styles for each model, trimming to min length\n",
    "    for model_name, accuracies in model_results_dict.items():\n",
    "        plt.plot(np.arange(len(accuracies)), accuracies,\n",
    "                label=model_name,\n",
    "                # color=colors.get(model_name, 'black'),\n",
    "                linestyle=line_styles.get(model_name, '-'),\n",
    "                marker=markers.get(model_name, 'o'),\n",
    "                markersize=7,\n",
    "                linewidth=3)\n",
    "\n",
    "    plt.xlabel(\"# of Concepts Intervened\", fontsize=16)\n",
    "    plt.ylabel(\"Accuracy\", fontsize=16)\n",
    "    # plt.title(f\"Intervention Efficiency - {dataset_name} Dataset\", fontsize=16)\n",
    "    plt.grid(alpha=0.3)\n",
    "\n",
    "    # Adjust x-ticks based on dataset\n",
    "    # if dataset_name == 'Derm7pt':\n",
    "    #     max_len = max(len(accs) for accs in model_results_dict.values())\n",
    "    #     x_ticks = np.arange(0, max_len, 1)\n",
    "    #     plt.xticks(x_ticks, x_ticks.astype(int), fontsize=16)\n",
    "    # elif dataset_name == 'RIVAL10':\n",
    "    #     max_len = max(len(accs) for accs in model_results_dict.values())\n",
    "    #     x_ticks = np.arange(0, max_len)\n",
    "    #     plt.xticks(x_ticks, x_ticks.astype(int), fontsize=16)\n",
    "    # else:\n",
    "    #     plt.xticks(fontsize=16)\n",
    "\n",
    "    plt.yticks(fontsize=16)\n",
    "\n",
    "    plt.legend(fontsize=16, loc='lower right')\n",
    "    plt.tight_layout()\n",
    "\n",
    "    output_dir = os.path.join(PROJECT_ROOT, 'output', 'plots', 'intervention')\n",
    "    os.makedirs(output_dir, exist_ok=True)\n",
    "    plt.savefig(os.path.join(output_dir, f'{use_dataset}.png'), dpi=600, bbox_inches='tight')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "581620ea",
   "metadata": {},
   "source": [
    "# Model 1: Logistic Regression Intervention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "d9d0d581",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intervention completed after 3 steps\n",
      "Final accuracy: 1.0000\n",
      "Intervention completed after 8 steps\n",
      "Final accuracy: 1.0000\n"
     ]
    }
   ],
   "source": [
    "# Calculate gain matrices for logistic regression\n",
    "lr_concept_indices_by_gain, lr_expected_values = compute_intervention_matrices_gain(\n",
    "    lin_model, lin_C_hat, lin_Y\n",
    ")\n",
    "\n",
    "# Run logistic regression intervention\n",
    "lr_1_accuracies = run_numpy_intervention(\n",
    "    lin_model, lin_C_hat, lin_Y,\n",
    "    lr_concept_indices_by_gain, lr_expected_values\n",
    ")\n",
    "\n",
    "\n",
    "lr_concept_indices_by_weight = compute_intervention_matrices_weight(\n",
    "    lin_model, lin_C_hat, lin_Y\n",
    ")\n",
    "\n",
    "lr_2_accuracies = run_numpy_intervention(\n",
    "    lin_model, lin_C_hat, lin_Y,\n",
    "    lr_concept_indices_by_weight, lr_expected_values\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "2b71c2cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(44, 18)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lr_concept_indices_by_weight.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f30eee7",
   "metadata": {},
   "source": [
    "# Model 2: CLC-L (Prototype) Intervention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "d9f0d85e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intervention completed after 4 steps\n",
      "Final accuracy: 1.0000\n"
     ]
    }
   ],
   "source": [
    "# Calculate gain matrices for prototype model\n",
    "proto_concept_indices_by_gain, proto_expected_values = compute_prototype_gain_matrices(\n",
    "    clc_model, clc_C_hat, clc_Y\n",
    ")\n",
    "\n",
    "# Run prototype model intervention\n",
    "proto_accuracies = run_torch_intervention(\n",
    "    clc_model, clc_C_hat, clc_Y,\n",
    "    proto_concept_indices_by_gain, proto_expected_values\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a44dbb0",
   "metadata": {},
   "source": [
    "# Model 3: CLC-D Intervention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "a2953f8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Calculate gain matrices for CLC-D (class-level concepts)\n",
    "# clc_d_concept_indices_by_gain = compute_class_level_gain_matrices(\n",
    "#     clc_C_hat, clc_Y, class_level_concepts\n",
    "# )\n",
    "\n",
    "# # Run CLC-D intervention with special accuracy calculation\n",
    "# clc_d_accuracies = run_torch_intervention(\n",
    "#     clc_model, clc_C_hat, clc_Y,\n",
    "#     clc_d_concept_indices_by_gain, clc_l_concept_values,\n",
    "#     use_clc_d_accuracy=True, class_level_concepts=class_level_concepts\n",
    "# )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8e1665a",
   "metadata": {},
   "source": [
    "# Visualization of Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "27e0a779",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compare all models\n",
    "model_results = {\n",
    "    'LR': lr_1_accuracies,\n",
    "    'LR-Weight': lr_2_accuracies,\n",
    "    'CLPC': proto_accuracies,\n",
    "    # 'CLC-D': clc_d_accuracies\n",
    "}\n",
    "\n",
    "plot_intervention_results(model_results, use_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "c52fe06f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1.],\n",
       "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1.],\n",
       "        [1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1.],\n",
       "        [1., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
       "        [1., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0., 1., 0., 0., 0., 0., 0., 1.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1.],\n",
       "        [0., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 1., 1.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 0.],\n",
       "        [0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 1., 1., 0.]],\n",
       "       device='mps:0', grad_fn=<IndexPutBackward0>)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clc_model.get_binary_prototypes()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a648850",
   "metadata": {},
   "source": [
    "# Analysis of Incorrect Classifications\n",
    "This section can be uncommented and used for further analysis of misclassified instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b52b9809",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Additional analysis code can be placed here\n",
    "# For example:\n",
    "#\n",
    "# def analyze_misclassifications(model, C_hat, Y_true, model_name):\n",
    "#     \"\"\"\n",
    "#     Analyze misclassified instances for a given model.\n",
    "#     \"\"\"\n",
    "#     if isinstance(C_hat, torch.Tensor):\n",
    "#         predictions = model.predict(C_hat)\n",
    "#         misclassified = (predictions != Y_true)\n",
    "#         misclassified_indices = torch.where(misclassified)[0].cpu().numpy()\n",
    "#     else:\n",
    "#         predictions = model.predict(C_hat)\n",
    "#         misclassified = (predictions != Y_true)\n",
    "#         misclassified_indices = np.where(misclassified)[0]\n",
    "#\n",
    "#     print(f\"{model_name} - Total misclassified: {len(misclassified_indices)}\")\n",
    "#\n",
    "#     # Further analysis...\n",
    "#\n",
    "#     return misclassified_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4727be4c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bab60750",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "3.11.9",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
